//    Copyright (C) Kherty.  All rights reserved.
using System.Windows;
using System.Windows.Media;
using OpenLS.Chart.UI.Internals;
using OpenLS.Core;
using OpenLS.Drawing;

namespace OpenLS.Chart.UI
{
    public class ChartElement : DependencyObject
    {


        public static object GetViewModel(DependencyObject obj)
        {
            return (object)obj.GetValue(ViewModelProperty);
        }

        public static void SetViewModel(DependencyObject obj, object value)
        {
            obj.SetValue(ViewModelProperty, value);
        }

        // Using a DependencyProperty as the backing store for ViewModel.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty ViewModelProperty =
            DependencyProperty.RegisterAttached("ViewModel", typeof(object), typeof(ChartElement), new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.Inherits));

        

        public static IFormatValueConverter  GetDateTimeConverter(DependencyObject obj)
        {
            return (IFormatValueConverter)obj.GetValue(DateTimeConverterProperty);
        }

        public static void SetDateTimeConverter(DependencyObject obj, IFormatValueConverter value)
        {
            obj.SetValue(DateTimeConverterProperty, value);
        }

        // Using a DependencyProperty as the backing store for MyProperty.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty DateTimeConverterProperty =
            DependencyProperty.RegisterAttached("DateTimeConverter", typeof(IFormatValueConverter), typeof(ChartElement), new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.Inherits));


        public static object    GetChartInfo(DependencyObject obj)
        {
            return (object)obj.GetValue(ChartInfoProperty);
        }

        public static void SetChartInfo(DependencyObject obj, object value)
        {
            obj.SetValue(ChartInfoProperty, value);
        }

        // Using a DependencyProperty as the backing store for ChartInfo.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty ChartInfoProperty =
            DependencyProperty.RegisterAttached("ChartInfo", typeof(object), typeof(ChartElement), new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.Inherits));



        public static object GetObjectContext(DependencyObject obj)
        {
            return obj.GetValue(ObjectContextProperty);
        }

        public static void SetObjectContext(DependencyObject obj, object value)
        {
            obj.SetValue(ObjectContextProperty, value);
        }

        // Using a DependencyProperty as the backing store for ObjectContext.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty ObjectContextProperty =
            DependencyProperty.RegisterAttached("ObjectContext", typeof(object), typeof(ChartElement), new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.Inherits));



        public static object    GetHelper(DependencyObject obj)
        {
            return obj.GetValue(HelperProperty);
        }

        public static void SetHelper(DependencyObject obj, object value)
        {
            obj.SetValue(HelperProperty, value);
        }

        // Using a DependencyProperty as the backing store for Helper.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty HelperProperty =
            DependencyProperty.RegisterAttached("Helper", typeof(object), typeof(ChartElement), new UIPropertyMetadata(null));




        public static FrameworkElement GetChartAreaOwner(DependencyObject obj)
        {
            return (FrameworkElement)obj.GetValue(ChartAreaOwnerProperty);
        }

        public static void SetChartAreaOwner(DependencyObject obj, FrameworkElement value)
        {
            obj.SetValue(ChartAreaOwnerProperty, value);
        }

        // Using a DependencyProperty as the backing store for ChartAreaOwner.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty ChartAreaOwnerProperty =
            DependencyProperty.RegisterAttached("ChartAreaOwner", typeof(FrameworkElement), typeof(ChartElement), new UIPropertyMetadata(null));



        public static object GetSelectedObject(DependencyObject obj)
        {
            return obj.GetValue(SelectedObjectProperty);
        }

        public static void SetSelectedObject(DependencyObject obj, object value)
        {
            obj.SetValue(SelectedObjectProperty, value);
        }

        // Using a DependencyProperty as the backing store for SelectedObject.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty SelectedObjectProperty =
            DependencyProperty.RegisterAttached("SelectedObject", typeof(object), typeof(ChartElement), new UIPropertyMetadata(null));



        public static Legend GetLegend(DependencyObject obj)
        {
            return (Legend)obj.GetValue(LegendProperty);
        }

        public static void SetLegend(DependencyObject obj, Legend value)
        {
            obj.SetValue(LegendProperty, value);
        }

        // Using a DependencyProperty as the backing store for Legend.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty LegendProperty =
            DependencyProperty.RegisterAttached("Legend", typeof(Legend), typeof(ChartElement), new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.Inherits));



        public static ShapePropertiesObserver GetShapePropertiesObserver(DependencyObject obj)
        {
            return (ShapePropertiesObserver)obj.GetValue(ShapePropertiesObserverProperty);
        }

        public static void SetShapePropertiesObserver(DependencyObject obj, ShapePropertiesObserver value)
        {
            obj.SetValue(ShapePropertiesObserverProperty, value);
        }

        // Using a DependencyProperty as the backing store for ShapePropertiesObserver.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty ShapePropertiesObserverProperty =
            DependencyProperty.RegisterAttached("ShapePropertiesObserver", typeof(ShapePropertiesObserver), typeof(ChartElement), new FrameworkPropertyMetadata(null,FrameworkPropertyMetadataOptions.Inherits));



        public static View3D GetView3D(DependencyObject obj)
        {
            return (View3D)obj.GetValue(View3DProperty);
        }

        public static void SetView3D(DependencyObject obj, View3D value)
        {
            obj.SetValue(View3DProperty, value);
        }

        // Using a DependencyProperty as the backing store for View3D.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty View3DProperty =
            DependencyProperty.RegisterAttached("View3D", typeof(View3D), typeof(ChartElement), new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.Inherits));



        public static PlotArea GetPlotArea(DependencyObject obj)
        {
            return (PlotArea)obj.GetValue(PlotAreaProperty);
        }

        public static void SetPlotArea(DependencyObject obj, PlotArea value)
        {
            obj.SetValue(PlotAreaProperty, value);
        }

        // Using a DependencyProperty as the backing store for PlotArea.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty PlotAreaProperty =
            DependencyProperty.RegisterAttached("PlotArea", typeof(PlotArea), typeof(ChartElement), new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.Inherits));



        public static Theme GetInheritedTheme(DependencyObject obj)
        {
            return (Theme)obj.GetValue(InheritedThemeProperty);
        }

        public static void SetInheritedTheme(DependencyObject obj, Theme value)
        {
            obj.SetValue(InheritedThemeProperty, value);
        }

        // Using a DependencyProperty as the backing store for InheritedTheme.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty InheritedThemeProperty =
            DependencyProperty.RegisterAttached("InheritedTheme", typeof(Theme), typeof(ChartElement), new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.Inherits));


        public static ChartArea GetChartArea(DependencyObject obj)
        {
            return (ChartArea)obj.GetValue(ChartAreaProperty);
        }

        public static void SetChartArea(DependencyObject obj, ChartArea value)
        {
            obj.SetValue(ChartAreaProperty, value);
        }

        // Using a DependencyProperty as the backing store for ChartArea.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty ChartAreaProperty =
            DependencyProperty.RegisterAttached("ChartArea", typeof(ChartArea), typeof(ChartElement), new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.Inherits));





        public static DataPoint GetDataPoint(DependencyObject obj)
        {
            return (DataPoint)obj.GetValue(DataPointProperty);
        }

        public static void SetDataPoint(DependencyObject obj, DataPoint value)
        {
            obj.SetValue(DataPointProperty, value);
        }

        // Using a DependencyProperty as the backing store for DataPoint.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty DataPointProperty =
            DependencyProperty.RegisterAttached("DataPoint", typeof(DataPoint), typeof(ChartElement), new UIPropertyMetadata(null));



        public static ChartStyle GetStyle(DependencyObject obj)
        {
            return (ChartStyle)obj.GetValue(StyleProperty);
        }

        public static void SetStyle(DependencyObject obj, ChartStyle value)
        {
            obj.SetValue(StyleProperty, value);
        }

        // Using a DependencyProperty as the backing store for Style.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty StyleProperty =
            DependencyProperty.RegisterAttached("Style", typeof(ChartStyle), typeof(ChartElement), new FrameworkPropertyMetadata(new ChartStyle(2), FrameworkPropertyMetadataOptions.Inherits));






        public static AxisInfo GetZAxisInfo(DependencyObject obj)
        {
            return (AxisInfo)obj.GetValue(ZAxisInfoProperty);
        }

        public static void SetZAxisInfo(DependencyObject obj, AxisInfo value)
        {
            obj.SetValue(ZAxisInfoProperty, value);
        }

        // Using a DependencyProperty as the backing store for ZAxisInfo.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty ZAxisInfoProperty =
            DependencyProperty.RegisterAttached("ZAxisInfo", typeof(AxisInfo), typeof(ChartElement), new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.Inherits));




        public static AxisInfo GetXAxisInfo(DependencyObject obj)
        {
            return (AxisInfo)obj.GetValue(XAxisInfoProperty);
        }

        public static void SetXAxisInfo(DependencyObject obj, AxisInfo value)
        {
            obj.SetValue(XAxisInfoProperty, value);
        }

        // Using a DependencyProperty as the backing store for XAxisInfo.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty XAxisInfoProperty =
            DependencyProperty.RegisterAttached("XAxisInfo", typeof(AxisInfo), typeof(ChartElement), new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.Inherits));




        public static AxisInfo GetYAxisInfo(DependencyObject obj)
        {
            return (AxisInfo)obj.GetValue(YAxisInfoProperty);
        }

        public static void SetYAxisInfo(DependencyObject obj, AxisInfo value)
        {
            obj.SetValue(YAxisInfoProperty, value);
        }

        // Using a DependencyProperty as the backing store for YAxisInfo.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty YAxisInfoProperty =
            DependencyProperty.RegisterAttached("YAxisInfo", typeof(AxisInfo), typeof(ChartElement), new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.Inherits));





        


        public static DataPointsObserver GetDataPointsObserver(DependencyObject obj)
        {
            return (DataPointsObserver)obj.GetValue(DataPointsObserverProperty);
        }

        public static void SetDataPointsObserver(DependencyObject obj, DataPointsObserver value)
        {
            obj.SetValue(DataPointsObserverProperty, value);
        }

        // Using a DependencyProperty as the backing store for DataPointsObserver.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty DataPointsObserverProperty =
            DependencyProperty.RegisterAttached("DataPointsObserver", typeof(DataPointsObserver), typeof(ChartElement), new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.Inherits));


        public static object GetObserver(DependencyObject obj)
        {
            return obj.GetValue(ObserverProperty);
        }

        public static void SetObserver(DependencyObject obj, object value)
        {
            obj.SetValue(ObserverProperty, value);
        }

        // Using a DependencyProperty as the backing store for Observer.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty ObserverProperty =
            DependencyProperty.RegisterAttached("Observer", typeof(object), typeof(ChartElement), new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.Inherits));


	
        public static Scaler GetVerticalScaler(DependencyObject obj)
        {
            return (Scaler)obj.GetValue(VerticalScalerProperty);
        }

        public static void SetVerticalScaler(DependencyObject obj, Scaler value)
        {
            obj.SetValue(VerticalScalerProperty, value);
        }

        // Using a DependencyProperty as the backing store for VerticalScaler.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty VerticalScalerProperty =
            DependencyProperty.RegisterAttached("VerticalScaler", typeof(Scaler), typeof(ChartElement), new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.Inherits));

        public static Scaler GetHorizontalScaler(DependencyObject obj)
        {
            return (Scaler)obj.GetValue(HorizontalScalerProperty);
        }

        public static void SetHorizontalScaler(DependencyObject obj, Scaler value)
        {
            obj.SetValue(HorizontalScalerProperty, value);
        }

        // Using a DependencyProperty as the backing store for HorizontalScaler.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty HorizontalScalerProperty =
            DependencyProperty.RegisterAttached("HorizontalScaler", typeof(Scaler), typeof(ChartElement), new FrameworkPropertyMetadata(null,FrameworkPropertyMetadataOptions.Inherits));


        // Using a DependencyProperty as the backing store for FillProperties.  This enables animation, styling, binding, etc...


        public static object GetDataPoints(DependencyObject obj)
        {
            return obj.GetValue(DataPointsProperty);
        }

        public static void SetDataPoints(DependencyObject obj, object value)
        {
            obj.SetValue(DataPointsProperty, value);
        }

        // Using a DependencyProperty as the backing store for DataPoints.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty DataPointsProperty =
            DependencyProperty.RegisterAttached("DataPoints", typeof(object), typeof(DependencyObject), new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.Inherits));




        public static ChartBase GetChart(DependencyObject obj)
        {
            return (ChartBase)obj.GetValue(ChartProperty);
        }

        public static void SetChart(DependencyObject obj, ChartBase value)
        {
            obj.SetValue(ChartProperty, value);
        }

        // Using a DependencyProperty as the backing store for Chart.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty ChartProperty =
            DependencyProperty.RegisterAttached("Chart", typeof(ChartBase), typeof(DependencyObject), new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.Inherits));


        public static bool GetVaryColors(DependencyObject obj)
        {
            return (bool)obj.GetValue(VaryColorsProperty);
        }

        public static void SetVaryColors(DependencyObject obj, bool value)
        {
            obj.SetValue(VaryColorsProperty, value);
        }

        // Using a DependencyProperty as the backing store for VaryColors.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty VaryColorsProperty =
            DependencyProperty.RegisterAttached("VaryColors", typeof(bool), typeof(DependencyObject), new FrameworkPropertyMetadata(false, FrameworkPropertyMetadataOptions.Inherits));

    }
}
